package convertor

import (
	"fmt"
	"strconv"
)

const version = 1.0

// 转换器实现
type convertorImpl struct {
	Version float64
}

// 构造
func NewConvertorImpl() convertor {
	return &convertorImpl{
		Version: version,
	}
}

/**
// 'b' (-ddddp±ddd，二进制指数)
// 'e' (-d.dddde±dd，十进制指数)
// 'E' (-d.ddddE±dd，十进制指数)
// 'f' (-ddd.dddd，没有指数)
// 'g' ('e':大指数，'f':其它情况)
// 'G' ('E':大指数，'f':其它情况)
*/

// 任意类型转字符串
func (c convertorImpl) ToString(v interface{}) string {
	switch d := v.(type) {
	case nil:
		return ""
	case int:
		return strconv.Itoa(d)
	case int32:
		return int32toString(d)
	case int64:
		return strconv.FormatInt(d, 10)
	case string:
		return d
	case float32:
		return strconv.FormatFloat(float64(d), 'f', -1, 32)
	case float64:
		return strconv.FormatFloat(d, 'f', -1, 64)
	case bool:
		return strconv.FormatBool(d)
	}
	return fmt.Sprint(v)
}

// 任意类型转字符串，可以设置默认返回值
// 如果为空字符串返回默认值
func (c convertorImpl) ToStringDefault(v interface{}, def string) string {
	s := c.ToString(v)
	if s == "" {
		s = def
	}
	return s
}

//// 任意类型转int类型
//// 发生异常返回0
func (c convertorImpl) ToInt(v interface{}) int {
	switch d := v.(type) {
	case nil:
		return 0
	case int:
		return d
	case int8:
		return int(d)
	case int16:
		return int(d)
	case int32:
		return int(d)
	case int64:
		return int64Bit(d)
	case string:
		//string到int
		tempD, _ := strconv.Atoi(d)
		return tempD
	case bool:
		//true:0 ,flash : 1
		return intToBool(d)
	}
	return 0
}

//// 任意类型转int类型，可以设置默认类型
//// 如果发生异常返回默认值
func (c convertorImpl) ToIntDefault(v interface{}, def int) int {
	s := c.ToInt(v)
	if s == 0 {
		s = def
	}
	return s
}

//// 任意类型转float64
//// 如果发生异常返回0
func (c convertorImpl) ToFloat64(v interface{}) float64 {
	switch d := v.(type) {
	case nil:
		return 0
	case string:
		i, _ := strconv.ParseFloat(d, 64)
		return i
	case float32:
		return float64(d)
	case float64:
		return d
	case int:
		return float64(d)
	case int32:
		return float64(d)
	case int64:
		return float64(d)
	case bool:
		//true:0 ,flash : 1
		return floatToBool(d)
	}
	return 0
}

//// 任意类型转float64，可以设置默认类型
//// 如果发生异常返回默认值
func (c convertorImpl) ToFloat64Default(v interface{}, def float64) float64 {
	s := c.ToFloat64(v)
	if s == 0 {
		s = def
	}
	return s
}
